home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 2d / allocate.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  15.6 KB  |  544 lines
  1. #include "includes.h"
  2.  
  3. /**************************************|****************************************
  4. Routine   : GimmeAPoolNode
  5. Input  par: none
  6. Output par: PoolNode * (pointer to PoolNode)
  7. Function  : Allocates a PoolNode structure. Initializes Next in 
  8.             structure PoolNode to zero.
  9. ***************************************|***************************************/
  10.  
  11.  PoolNode *GimmeAPoolNode(void)
  12.   {
  13.    PoolNode *p=(PoolNode *)malloc(sizeof(PoolNode));
  14.    if (p==NULL) 
  15.    ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolNode not able to allocate structure");
  16.    p->x=p->y=p->z=0;
  17.    p->Features=NULL; /* initialize */
  18.    p->Distance=NULL;
  19.    p->Index=NULL;
  20.    p->Next=NULL;
  21.    return p;
  22.   }
  23.  
  24. /**************************************|****************************************
  25. Routine   : FreeMeAPoolNode"
  26. Input  par: PoolNode *El (pointer to PoolNode) 
  27. Output par: none
  28. Function  : Frees a PoolNode structure.
  29. ***************************************|***************************************/
  30.  
  31.  void FreeMeAPoolNode(PoolNode *p)
  32.   {
  33.    if (p==NULL) ErrorHandler(NULL_POINTER,"FreeMeAPoolNode with null pointer");
  34.    free(p);
  35.   }
  36.  
  37. /**************************************|****************************************
  38. Routine   : GimmeAPoolStructure"
  39. Input  par: none
  40. Output par: PoolStructure * (pointer to PoolStructure)
  41. Function  : Allocates a PoolStructure. Initializes pointers to Edges,
  42.             Shadesto null and B, D = 0.
  43. ***************************************|***************************************/
  44.  
  45.  PoolStructure *GimmeAPoolStructure(void)
  46.   {
  47.    PoolStructure *p=(PoolStructure *)malloc(sizeof(PoolStructure));
  48.    if (p==NULL) 
  49.    ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolStructure not able to allocate structure");
  50.    p->DomainNodes=p->RangeNodes=NULL;
  51.    p->Next=NULL;
  52.    p->D=p->B=0;
  53.    return p;
  54.   }
  55.  
  56. /**************************************|****************************************
  57. Routine   : FreeMeAPoolStructure"
  58. Input  par: PoolStructure *p (pointer to PoolStructure) 
  59. Output par: none
  60. Function  : Frees a PoolStructure.
  61. ***************************************|***************************************/
  62.  
  63.  void FreeMeAPoolStructure(PoolStructure *p)
  64.   {
  65.    if (p==NULL) ErrorHandler(NULL_POINTER,"FreeMeAPoolStructure with null pointer");
  66.    free(p);
  67.   }
  68.  
  69. /**************************************|****************************************
  70. Routine   : GimmeAPoolNodeArray"
  71. Input  par: int xsize (x size of PoolNodearray)
  72.             int ysize (y size of PoolNodearray)
  73. Output par: PoolNode ***  (pointer to 2D array of PoolNode-pointers)
  74. Function  : Allocates a 2D structure of Poolnodes. No Initializing.
  75. ***************************************|***************************************/
  76.  
  77.  PoolNode ***GimmeAPoolNodeArray(int xsize,int ysize)
  78.   {
  79.    int i;
  80.    PoolNode ***Array;
  81.    
  82.    Array=(PoolNode ***) calloc(xsize,sizeof(PoolNode **));
  83.    if (Array==NULL) 
  84.    ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolNodeArray3D not able to allocate struture");
  85.    for (i=0;i<xsize;i++)
  86.     {
  87.      Array[i]=(PoolNode **) calloc(ysize,sizeof(PoolNode *));
  88.      if (Array[i]==NULL) 
  89.      ErrorHandler(NO_FREE_MEMORY,"GimmeAPoolNodeArray3D not able to allocate structure");
  90.     }
  91.    return Array;
  92.   }
  93.  
  94. /**************************************|****************************************
  95. Routine   : FreeMeAPoolNodeArray"
  96. Input  par: PoolArray *p (pointer to PoolNodeArray)
  97.             int xsize    (xsize of array) 
  98. Output par: none
  99. Function  : Frees a PoolNodeArray Node.
  100. ***************************************|***************************************/
  101.  
  102.  void FreeMeAPoolNodeArray(PoolNode ****p,int xsize)
  103.   {
  104.    register unsigned int i;
  105.    
  106.    if (p==NULL) ErrorHandler(NULL_POINTER,"FreeMeAPoolNodeArray3D with null pointer");
  107.    for (i=0;i<xsize;i++) 
  108.     {
  109.      free(p[i]);
  110.     }
  111.    free(p);
  112.   }
  113.  
  114. /**************************************|****************************************
  115. Routine   : GimmeATransformation"
  116. Input  par: none
  117. Output par: Transformation * (pointer to Transformation)
  118. Function  : Allocates a Transformation structure. Initializes Domain and Sub.
  119. ***************************************|***************************************/
  120.  
  121.  Transformation *GimmeATransformation(void)
  122.   {
  123.    Transformation *p=(Transformation *)malloc(sizeof(Transformation));
  124.    if (p==NULL) 
  125.    ErrorHandler(NO_FREE_MEMORY,"GimmeATransformation not able to allocate structure");
  126.    p->Domain=NULL; /* initialize */
  127.    p->Sub=NULL;
  128.    return p;
  129.   }
  130.  
  131. /**************************************|****************************************
  132. Routine   : FreeMeATransformation"
  133. Input  par: Transformation *Tr (pointer to Transformation) 
  134. Output par: none
  135. Function  : Frees a Transformation structure.
  136. ***************************************|***************************************/
  137.  
  138.  void FreeMeATransformation(Transformation *Tr)
  139.   {
  140.    if (Tr==NULL) ErrorHandler(NULL_POINTER,"FreeMeATransformation with null pointer");
  141.    free(Tr);
  142.   }
  143.  
  144. /**************************************|****************************************
  145. Routine   : GimmeATransArray"
  146. Input  par: int xsize (x size of transarray)
  147.             int ysize (y size of transarray)
  148. Output par: Transformation *** (pointer to 2D array of transformation-pointers)
  149. Function  : Allocates a 2D structure of transformationpointers. No Initializing.
  150. ***************************************|***************************************/
  151.  
  152.  
  153.  Transformation ***GimmeATransArray(int xsize,int ysize)
  154.   {
  155.    int i;
  156.    Transformation ***Array;
  157.    
  158.    Array=(Transformation ***) calloc(xsize,sizeof(Transformation **));
  159.    if (Array==NULL) 
  160.    ErrorHandler(NO_FREE_MEMORY,"GimmeATransArray3D not able to allocate struture");
  161.    for (i=0;i<xsize;i++)
  162.     {
  163.      Array[i]=(Transformation **) calloc(ysize,sizeof(Transformation *));
  164.      if (Array[i]==NULL) 
  165.      ErrorHandler(NO_FREE_MEMORY,"GimmeATransArray3D not able to allocate structure");
  166.     }
  167.    return Array;
  168.   }
  169.  
  170. /**************************************|****************************************
  171. Routine   : FreeMeATransArray"
  172. Input  par: TransArray *Tr (pointer to TransArray)
  173.             int xsize      (xsize of array) 
  174. Output par: none
  175. Function  : Frees a TransArray structure.
  176. ***************************************|***************************************/
  177.  
  178.  void FreeMeATransArray3D(Transformation ****Tr,int xsize,int ysize)
  179.   {
  180.    register unsigned int i,j;
  181.    
  182.    if (Tr==NULL) ErrorHandler(NULL_POINTER,"FreeMeATransArray3D with null pointer");
  183.    for (i=0;i<xsize;i++)
  184.     {
  185.      for (j=0;i<ysize;j++) free(Tr[i][j]);
  186.      free(Tr[i]);
  187.     }
  188.    free(Tr);
  189.   }
  190.  
  191. /**************************************|****************************************
  192. Routine   : GimmeAParameter"
  193. Input  par: none
  194. Output par: Parameter * (pointer to Parameter)
  195. Function  : Allocates a Parameter structure. No initializing.
  196. ***************************************|***************************************/
  197.  
  198.  Parameter *GimmeAParameter(void)
  199.   {
  200.    Parameter *p=(Parameter *)malloc(sizeof(Parameter));
  201.    if (p==NULL) 
  202.    ErrorHandler(NO_FREE_MEMORY,"GimmeAParameter not able to allocate structure");
  203.    return p;
  204.   }
  205.  
  206. /**************************************|****************************************
  207. Routine   : FreeMeAParameter"
  208. Input  par: Parameter *p (pointer to Parameter) 
  209. Output par: none
  210. Function  : Frees a Parameter structure.
  211. ***************************************|***************************************/
  212.  
  213.  void FreeMeAParameter(Parameter *p)
  214.   {
  215.    if (p==NULL) ErrorHandler(NULL_POINTER,"FreeMeAParameter with null pointer");
  216.    free(p);
  217.   }
  218.  
  219. /**************************************|****************************************
  220. Routine   : GimmeABitamap"
  221. Input  par: int xsize (x size of bitmap)
  222.             int ysize (y size of bitmap)
  223. Output par: BitMap *  (pointer to BitMap)
  224. Function  : Allocates a BitMap structure of size x,y. Initialize XSize=x 
  225.             YSize=y  Map->Gfx array  ImgType=type
  226.             Bitmap image is initialized to 0'oes.
  227. ***************************************|***************************************/
  228.  
  229.  BitMap *GimmeABitMap(int xsize, int ysize, int type)
  230.   {
  231.    int i;
  232.    BitMap *Gfx;
  233.    unsigned char **Array;
  234.    
  235.    Gfx=(BitMap *) malloc(sizeof(BitMap));
  236.    if (Gfx==NULL) 
  237.    ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap not able to allocate structure");
  238.    
  239.    Array=(unsigned char **) calloc(xsize,sizeof(unsigned char *));
  240.    if (Array==NULL) 
  241.    ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap not able to allocate structure");
  242.    for (i=0;i<xsize;i++)
  243.     {
  244.      Array[i]=(unsigned char *) calloc(ysize,sizeof(unsigned char));
  245.      if (Array[i]==NULL) 
  246.      ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap not able to allocate structure");
  247.     }
  248.    Gfx->Map=Array;  /* initialize */
  249.    Gfx->XSize=xsize;
  250.    Gfx->YSize=ysize;
  251.    Gfx->ImgType=type;
  252.    
  253.    return Gfx;
  254.   }
  255.  
  256. /**************************************|****************************************
  257. Routine   : FreeMeABitMap"
  258. Input  par: BitMap *Bm (pointer to BitMap) 
  259. Output par: none
  260. Function  : Frees a BitMap structure.
  261. ***************************************|***************************************/
  262.  
  263.  void FreeMeABitMap(BitMap *Bm)
  264.   {
  265.    register int i;
  266.    if (Bm==NULL) ErrorHandler(NULL_POINTER,"FreeMeABitMap with null pointer");
  267.    
  268.    for(i=0;i<Bm->XSize;i++) free(Bm->Map[i]);
  269.    free(Bm->Map);
  270.    free(Bm);
  271.   }
  272.  
  273.  
  274.  ListNode *GimmeAListNode(void)
  275.   {
  276.    ListNode *p=(ListNode *)malloc(sizeof(ListNode));
  277.    if (p==NULL) 
  278.    ErrorHandler(NO_FREE_MEMORY,"GimmeAListNode not able to allocate structure");
  279.    p->Info=0;
  280.    p->Domain=NULL; /* initialize */
  281.    p->Next=NULL; /* initialize */
  282.    p->Pred=NULL;
  283.    
  284.    return p;
  285.   }
  286.  
  287.  
  288.  BitMap3D *GimmeABitMap3D(int xsize, int ysize, int zsize, int type)
  289.   {
  290.    register int i,j;
  291.    BitMap3D *Gfx;
  292.    unsigned char ***Array;
  293.    
  294.    Gfx=(BitMap3D *) malloc(sizeof(BitMap3D));
  295.    if (Gfx==NULL) 
  296.    ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap3D not able to allocate structure");
  297.    
  298.    Array=(unsigned char ***) calloc(xsize,sizeof(unsigned char **));
  299.    if (Array==NULL) 
  300.    ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap3D not able to allocate structure");
  301.    for (i=0;i<xsize;i++)
  302.     {
  303.      Array[i]=(unsigned char **) calloc(ysize,sizeof(unsigned char*));
  304.      if (Array[i]==NULL) 
  305.      ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap3D not able to allocate structure");
  306.      for (j=0;j<ysize;j++)
  307.       {
  308.        Array[i][j]=(unsigned char *) calloc(zsize,sizeof(unsigned char));
  309.        if (Array[i][j]==NULL) 
  310.        ErrorHandler(NO_FREE_MEMORY,"GimmeABitMap3D not able to allocate structure");
  311.       }
  312.     }
  313.    Gfx->Map=Array;   /* initialize */
  314.    Gfx->XSize=xsize;
  315.    Gfx->YSize=ysize;
  316.    Gfx->ZSize=zsize;
  317.    Gfx->ImgType=type;
  318.    
  319.    return Gfx;
  320.   }
  321.  
  322. /**************************************|****************************************
  323. Routine   : FreeMeABitMap3D"
  324. Input  par: BitMap3D *Bm (pointer to BitMap3D) 
  325. Output par: none
  326. Function  : Frees a BitMap3D structure.
  327. ***************************************|***************************************/
  328.  
  329.  void FreeMeABitMap3D(BitMap3D *Bm)
  330.   {
  331.    register int i,j;
  332.    if (Bm==NULL) ErrorHandler(NULL_POINTER,"FreeMeABitMap3D with null pointer");
  333.    
  334.    for(i=0;i<Bm->XSize;i++) 
  335.     {
  336.      for(j=0;j<Bm->YSize;j++) free(Bm->Map[i][j]);
  337.      free(Bm->Map[i]);
  338.     }
  339.    free(Bm->Map);
  340.    free(Bm);
  341.   }
  342.  
  343.  
  344.  void FreeMeAListNode(ListNode *El)
  345.   {
  346.    if (El==NULL) ErrorHandler(NULL_POINTER,"FreeMeAListNode with null pointer");
  347.    free(El);
  348.   }
  349.  
  350.  void FreeMeAList(ListNode *LP)
  351.   {
  352.    ListNode *tmp2,*tmp=LP,*Start=LP;
  353.    if (LP==NULL) ErrorHandler(NULL_POINTER,"FreeMeAList with null pointer");
  354.    do 
  355.     {
  356.      tmp2=tmp;
  357.      tmp=tmp->Next;
  358.      FreeMeAListNode(tmp2);
  359.     }
  360.    while((tmp!=NULL) && (tmp!=Start));
  361.   }
  362.  
  363.  float *GimmeAFloatArray(int n) 
  364.   {
  365.    float *p=(float *)calloc(n,sizeof(float));
  366.    if (p==NULL) 
  367.    ErrorHandler(NO_FREE_MEMORY,"GimmeAFloatArray not able to allocate structure");
  368.    return p;
  369.   }
  370.  
  371.  void FreeMeAFloatArray(float *Pa)
  372.   {
  373.    if (Pa==NULL) 
  374.    ErrorHandler(NULL_POINTER,"FreeMeAFloatArray with null pointer");
  375.    free(Pa);
  376.   }
  377.  
  378.  long double *GimmeADoubleArray(int n) 
  379.   {
  380.    long double *p=(long double *)calloc(n,sizeof(long double));
  381.    if (p==NULL) 
  382.    ErrorHandler(NO_FREE_MEMORY,"GimmeADoubleArray not able to allocate structure");
  383.    return p;
  384.   }
  385.  
  386.  void FreeMeADoubleArray(double *Pa)
  387.   {
  388.    if (Pa==NULL) 
  389.    ErrorHandler(NULL_POINTER,"FreeMeADoubleArray with null pointer");
  390.    free(Pa);
  391.   }
  392.  
  393.  int *GimmeAIntArray(int n) 
  394.   {
  395.    int *p=(int *)calloc(n,sizeof(int));
  396.    if (p==NULL) ErrorHandler(NO_FREE_MEMORY,"GimmeAIntArray not able to allocate structure");
  397.    return p;
  398.   }
  399.  
  400.  void FreeMeAIntArray(int *Pa)
  401.   {
  402.    if (Pa==NULL) 
  403.    ErrorHandler(NULL_POINTER,"FreeMeAIntArray with null pointer");
  404.    free(Pa);
  405.   }
  406.  
  407.  unsigned int *GimmeAUIntArray(int n) 
  408.   {
  409.    unsigned int *p=(unsigned int *)calloc(n,sizeof(unsigned int));
  410.    if (p==NULL) 
  411.    ErrorHandler(NO_FREE_MEMORY,"GimmeAUIntArray not able to allocate structure");
  412.    return p;
  413.   }
  414.  
  415.  void FreeMeAUIntArray(unsigned int *Pa)
  416.   {
  417.    if (Pa==NULL) 
  418.    ErrorHandler(NULL_POINTER,"FreeMeAUIntArray with null pointer");
  419.    free(Pa);
  420.   }
  421.  
  422.  long *GimmeALongArray(int n) 
  423.   {
  424.    long *p=(long *)calloc(n,sizeof(long));
  425.    if (p==NULL) 
  426.    ErrorHandler(NO_FREE_MEMORY,"GimmeALongArray not able to allocate structure");
  427.    return p;
  428.   }
  429.  
  430.  void FreeMeALongArray(long *Pa)
  431.   {
  432.    if (Pa==NULL) 
  433.    ErrorHandler(NULL_POINTER,"FreeMeALongArray with null pointer");
  434.    free(Pa);
  435.   }
  436.  
  437.  unsigned long *GimmeAULongArray(int n) 
  438.   {
  439.    unsigned long *p=(unsigned long *)calloc(n,sizeof(unsigned long));
  440.    if (p==NULL) 
  441.    ErrorHandler(NO_FREE_MEMORY,"GimmeAULongArray not able to allocate structure");
  442.    return p;
  443.   }
  444.  
  445.  void FreeMeAULongArray(unsigned long *Pa)
  446.   {
  447.    if (Pa==NULL) 
  448.    ErrorHandler(NULL_POINTER,"FreeMeAULongArray with null pointer");
  449.    free(Pa);
  450.   }
  451.  
  452.  LimboHeader *GimmeALimboHeader(void) 
  453.   {
  454.    LimboHeader *p=(LimboHeader *)malloc(sizeof(LimboHeader));
  455.    if (p==NULL) 
  456.    ErrorHandler(NO_FREE_MEMORY,"GimmeALimboHeader not able to allocate structure");
  457.    return p;
  458.   }
  459.  
  460.  void FreeMeALimboHeader(LimboHeader *head)
  461.   {
  462.    if (head==NULL) 
  463.    ErrorHandler(NULL_POINTER,"FreeMeALimboHeader with null pointer");
  464.    free(head);
  465.   }
  466.  
  467.  
  468.  FeatureSpace *GimmeAFeatureSpace(int dim,int size)
  469.   {
  470.    FeatureSpace *S;
  471.    
  472.    S=(FeatureSpace *)malloc(sizeof(FeatureSpace));
  473.    if (S==NULL) 
  474.    ErrorHandler(NO_FREE_MEMORY,"GimmeAFeatureSpace not able to allocate structure");
  475.    S->Dimension=dim;
  476.    S->Size=size;
  477.    S->GridArray=GimmeAGrid(dim,size);
  478.    
  479.    return S;
  480.   }
  481.  
  482.  void FreeMeAFeatureSpace(FeatureSpace *S)
  483.   {
  484.    if (S==NULL) ErrorHandler(NULL_POINTER,"FreeMeAFeatureSpace with null pointer");
  485.    
  486.    if (S->GridArray!=NULL) FreeMeAGrid(S->GridArray,S->Dimension,S->Size);
  487.    free(S);
  488.   }
  489.  
  490.  Grid *GimmeAGrid(int dim,int size)
  491.   {
  492.    Grid *G=NULL;
  493.    GridTerm *GT;
  494.    register int i;
  495.    
  496.    if (dim>0) 
  497.     {
  498.      G=(Grid *)malloc(sizeof(Grid));
  499.      if (G==NULL) 
  500.      ErrorHandler(NO_FREE_MEMORY,"GimmeAGrid not able to allocate structure");
  501.      G->Next=(Grid **)calloc(size,sizeof(Grid *));
  502.      if (G->Next==NULL)
  503.      ErrorHandler(NO_FREE_MEMORY,"GimmeAGrid not able to allocate structure");
  504.      for (i=0;i<size;i++) G->Next[i]=GimmeAGrid(dim-1,size);
  505.     }
  506.    
  507.    if (dim==0)
  508.     {
  509.      GT=(GridTerm *)malloc(sizeof(GridTerm));
  510.      if (GT==NULL)
  511.      ErrorHandler(NO_FREE_MEMORY,"GimmeAGrid not able to allocate structure");
  512.      GT->Class=NULL;
  513.      GT->Count=0;
  514.      G=(Grid *)GT;
  515.     }
  516.    
  517.    return G;
  518.   }
  519.  
  520.  void FreeMeAGrid(Grid *G,int Dim,int Size)
  521.   {
  522.    register int i;
  523.    if (G==NULL)
  524.    ErrorHandler(NULL_POINTER,"FreeMeAGrid with null pointer");
  525.    
  526.    if(Dim>0)
  527.     {
  528.      if (G->Next!=NULL) 
  529.      for(i=0;i<Size;i++)
  530.       {
  531.        FreeMeAGrid(G->Next[i],Dim-1,Size);
  532.        free(G->Next[i]);
  533.       }
  534.     }
  535.    else 
  536.     {
  537.      if (G->Next!=NULL) 
  538.      for(i=0;i<Size;i++) free((GridTerm *)G->Next[i]);
  539.     }
  540.    free(G);
  541.   }
  542.  
  543.  
  544.